home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / internet / other / ka9q / nhclb120.zoo / session.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-28  |  8.7 KB  |  459 lines
  1. /* Session control */
  2. #include <stdio.h>
  3. #include "global.h"
  4. #include "config.h"
  5. #include "mbuf.h"
  6. #include "netuser.h"
  7. #include "timer.h"
  8. #include "tcp.h"
  9. #include "ax25.h"
  10. #include "lapb.h"
  11. #include "iface.h"
  12. #include "ftp.h"
  13. #include "telnet.h"
  14. #ifdef _FINGER
  15. #include "finger.h"
  16. #endif
  17. #ifdef NETROM
  18. #include "netrom.h"
  19. #include "nr4.h"
  20. #endif
  21. #include "session.h"
  22. #include "cmdparse.h"
  23. #ifdef    UNIX
  24. #include <string.h>
  25. #endif
  26.  
  27. struct session *sessions;
  28. struct session *current;
  29. char notval[] = "Not a valid control block\n";
  30. char badsess[] = "Invalid session\n";
  31.  
  32. /* Convert a character string containing a decimal session index number 
  33.  * into a pointer. If the arg is NULLCHAR, use the current default session.
  34.  * If the index is out of range or unused, return NULLSESSION.
  35.  */
  36. static struct session *
  37. sessptr(cp)
  38. char *cp;
  39. {
  40.     register struct session *s;
  41.     unsigned int i;
  42.  
  43.     if(cp == NULLCHAR){
  44.         s = current;
  45.     } else {
  46.         if((i = atoi(cp)) >= nsessions)
  47.             return NULLSESSION;
  48.         s = &sessions[i];
  49.     }
  50.     if(s == NULLSESSION || s->type == FREE)
  51.         return NULLSESSION;
  52.  
  53.     return s;
  54. }
  55.  
  56. /* Select and display sessions */
  57. dosession(argc,argv)
  58. int argc;
  59. char *argv[];
  60. {
  61.     struct session *s;
  62.     extern char *tcpstates[];
  63.     char *psocket();
  64.     extern char *ax25states[];
  65.     char *tcp_port();
  66.  
  67.     if(argc > 1){
  68.         if((current = sessptr(argv[1])) != NULLSESSION)
  69.             go_mode();
  70.         return 0;
  71.     }
  72.     printf(" #       &CB Type   Rcv-Q  State        Remote socket\n");
  73.     for(s=sessions; s < &sessions[nsessions];s++){
  74.         switch(s->type){
  75.         case TELNET:
  76.             printf("%c%-3d%8lx Telnet  %4d  %-13s%-s:%s",
  77.              (current == s)? '*':' ',
  78.              (int)(s - sessions),
  79.              (long)s->cb.telnet->tcb,
  80.              s->cb.telnet->tcb->rcvcnt,
  81.              tcpstates[s->cb.telnet->tcb->state],
  82.              s->name,
  83.              tcp_port(s->cb.telnet->tcb->conn.remote.port));
  84.             break;
  85.         case FTP:
  86.             printf("%c%-3d%8lx FTP     %4d  %-13s%-s:%s",
  87.              (current == s)? '*':' ',
  88.              (int)(s - sessions),
  89.              (long)s->cb.ftp->control,
  90.              s->cb.ftp->control->rcvcnt,
  91.              tcpstates[s->cb.ftp->control->state],
  92.              s->name,
  93.              tcp_port(s->cb.ftp->control->conn.remote.port));
  94.             break;
  95. #ifdef    AX25
  96.         case AX25TNC:
  97.             printf("%c%-3d%8lx AX25    %4d  %-13s%-s",
  98.              (current == s)? '*':' ',
  99.              (int)(s - sessions),
  100.              (long)s->cb.ax25_cb,
  101.             len_mbuf(s->cb.ax25_cb->rxq),
  102.              ax25states[s->cb.ax25_cb->state],
  103.              s->name);
  104.             break;
  105. #endif
  106. #ifdef    _FINGER
  107.         case FINGER:
  108.             printf("%c%-3d%8lx Finger  %4d  %-13s%-s",
  109.              (current == s)? '*':' ',
  110.              (int)(s - sessions),
  111.              (long)s->cb.finger->tcb,
  112.              s->cb.finger->tcb->rcvcnt,
  113.              tcpstates[s->cb.finger->tcb->state],
  114.              s->name, s->cb.finger->tcb->conn.remote.port);
  115.             break;
  116. #endif
  117. #ifdef NETROM
  118.         case NRSESSION:
  119.             printf("%c%-3d%8lx NET/ROM %4d  %-13s%-s",
  120.              (current == s)? '*':' ',
  121.              (int)(s - sessions),
  122.              (long)s->cb.nr4_cb,
  123.             len_mbuf(s->cb.nr4_cb->rxq),
  124.              Nr4states[s->cb.nr4_cb->state],
  125.              s->name);
  126.             break;
  127. #endif
  128.         default:
  129.             continue;
  130.         }
  131.         if(s->rfile != NULLCHAR || s->ufile != NULLCHAR)
  132.             printf("\t");
  133.         if(s->rfile != NULLCHAR)
  134.             printf("Record: %s ",s->rfile);
  135.         if(s->ufile != NULLCHAR)
  136.             printf("Upload: %s",s->ufile);
  137.         printf("\n");
  138.     }
  139.     return 0;
  140. }
  141.  
  142. /* Enter conversational mode with current session */
  143. int
  144. go_mode()
  145. {
  146.     if(current == NULLSESSION || current->type == FREE)
  147.         return 0;
  148.     if (current->type == TELNET)
  149.         tel_setterm(current->cb.telnet);
  150.     go();
  151. }
  152.  
  153.  
  154. int
  155. go()
  156. {
  157.     void rcv_char(),ftpccr(),ax_rx(),fingcli_rcv() ;
  158.  
  159.     if(current == NULLSESSION || current->type == FREE)
  160.         return 0;
  161.     mode = CONV_MODE;
  162.     switch(current->type){
  163.     case TELNET:
  164.         rcv_char(current->cb.telnet->tcb,0); /* Get any pending input */
  165.         break;
  166.     case FTP:
  167.         ftpccr(current->cb.ftp->control,0);
  168.         break;
  169. #ifdef    AX25
  170.     case AX25TNC:
  171.         ax_rx(current->cb.ax25_cb,0);
  172.         break;
  173. #endif
  174. #ifdef _FINGER
  175.     case FINGER:
  176.         fingcli_rcv(current->cb.finger->tcb,0) ;
  177.         break ;
  178. #endif
  179. #ifdef    NETROM
  180.     case NRSESSION:
  181.         nr4_rx(current->cb.nr4_cb,0) ;
  182.         break ;
  183. #endif
  184.     }
  185.     return 0;
  186. }
  187. doclose(argc,argv)
  188. int argc;
  189. char *argv[];
  190. {
  191.     struct session *s;
  192.  
  193.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  194.         printf(badsess);
  195.         return -1;
  196.     }
  197.     switch(s->type){
  198.     case TELNET:
  199.         close_tcp(s->cb.telnet->tcb);
  200.         break;
  201.     case FTP:
  202.         close_tcp(s->cb.ftp->control);
  203.         break;
  204. #ifdef    AX25
  205.     case AX25TNC:
  206.         disc_ax25(s->cb.ax25_cb);
  207.         break;
  208. #endif
  209. #ifdef _FINGER
  210.     case FINGER:
  211.         close_tcp(s->cb.finger->tcb);
  212.         break;
  213. #endif
  214. #ifdef NETROM
  215.     case NRSESSION:
  216.         disc_nr4(s->cb.nr4_cb) ;
  217.         break ;
  218. #endif
  219.     }
  220.     return 0;
  221. }
  222. doreset(argc,argv)
  223. int argc;
  224. char *argv[];
  225. {
  226.     long htol();
  227.     struct session *s;
  228.  
  229.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  230.         printf(badsess);
  231.         return -1;
  232.     }
  233.     switch(s->type){
  234.     case TELNET:
  235.         reset_tcp(s->cb.telnet->tcb);
  236.         break;
  237.     case FTP:
  238.         if(s->cb.ftp->data != NULLTCB){
  239.             reset_tcp(s->cb.ftp->data);
  240.             s->cb.ftp->data = NULLTCB;
  241.         }
  242.         reset_tcp(s->cb.ftp->control);
  243.         break;
  244. #ifdef    AX25
  245.     case AX25TNC:
  246.         reset_ax25(s->cb.ax25_cb);
  247.         break;
  248. #endif
  249. #ifdef _FINGER
  250.     case FINGER:
  251.         reset_tcp(s->cb.finger->tcb);
  252.         break;
  253. #endif
  254. #ifdef NETROM
  255.     case NRSESSION:
  256.         reset_nr4(s->cb.nr4_cb) ;
  257.         break ;
  258. #endif
  259.     }
  260.     return 0;
  261. }
  262. int
  263. dokick(argc,argv)
  264. int argc;
  265. char *argv[];
  266. {
  267.     long htol();
  268.     void tcp_timeout();
  269.     struct session *s;
  270.  
  271.     if((s = sessptr(argc > 1 ? argv[1] : NULLCHAR)) == NULLSESSION){
  272.         printf(badsess);
  273.         return -1;
  274.     }
  275.     switch(s->type){
  276.     case TELNET:
  277.         if(kick_tcp(s->cb.telnet->tcb) == -1){
  278.             printf(notval);
  279.             return 1;
  280.         }
  281.         break;
  282.     case FTP:
  283.         if(kick_tcp(s->cb.ftp->control) == -1){
  284.  
  285.             printf(notval);
  286.             return 1;
  287.         }
  288.         if(s->cb.ftp->data != NULLTCB)
  289.             kick_tcp(s->cb.ftp->data);
  290.         break;
  291. #ifdef    AX25
  292.     case AX25TNC:
  293.         if(kick_ax25(s->cb.ax25_cb) == -1){
  294.             printf(notval);
  295.             return 1;
  296.         }
  297.         return 1;
  298. #endif
  299. #ifdef _FINGER
  300.     case FINGER:
  301.         if(kick_tcp(s->cb.finger->tcb) == -1){
  302.             printf(notval);
  303.             return 1;
  304.         }
  305.         break;
  306. #endif
  307. #ifdef NETROM
  308.     case NRSESSION:
  309.         if(kick_nr4(s->cb.nr4_cb) == -1) {
  310.             printf(notval) ;
  311.             return 1 ;
  312.         }
  313.         break ;
  314. #endif
  315.     }
  316.     return 0;
  317. }
  318. struct session *
  319. newsession()
  320. {
  321.     register int i;
  322.  
  323.     for(i=0;i<nsessions;i++)
  324.         if(sessions[i].type == FREE)
  325.             return &sessions[i];
  326.     return NULLSESSION;
  327. }
  328. freesession(s)
  329. struct session *s;
  330. {
  331.     if(s == NULLSESSION)
  332.         return;
  333.     if(s->record != NULLFILE){
  334.         fclose(s->record);
  335.         s->record = NULLFILE;
  336.     }
  337.     if(s->rfile != NULLCHAR){
  338.         free(s->rfile);
  339.         s->rfile = NULLCHAR;
  340.     }
  341.     if(s->upload != NULLFILE){
  342.         fclose(s->upload);
  343.         s->upload = NULLFILE;
  344.     }
  345.     if(s->ufile != NULLCHAR){
  346.         free(s->ufile);
  347.         s->ufile = NULLCHAR;
  348.     }
  349.     if(s->name != NULLCHAR){
  350.         free(s->name);
  351.         s->name = NULLCHAR;
  352.     }
  353.     s->type = FREE;
  354. }
  355. /* Control session recording */
  356. dorecord(argc,argv)
  357. int argc;
  358. char *argv[];
  359. {
  360.     if(current == NULLSESSION){
  361.         printf("No current session\n");
  362.         return 1;
  363.     }
  364.     if(argc > 1){
  365.         if(current->rfile != NULLCHAR){
  366.             fclose(current->record);
  367.             free(current->rfile);
  368.             current->record = NULLFILE;
  369.             current->rfile = NULLCHAR;
  370.         }
  371.         /* Open new record file, unless file name is "off", which means
  372.          * disable recording
  373.          */
  374.         if(strcmp(argv[1],"off") != 0
  375.          && (current->record = fopen(argv[1],"a")) != NULLFILE){
  376.             current->rfile = malloc((unsigned)strlen(argv[1])+1);
  377.             strcpy(current->rfile,argv[1]);
  378.         }
  379.     }
  380.     if(current->rfile != NULLCHAR)
  381.         printf("Recording into %s\n",current->rfile);
  382.     else
  383.         printf("Recording off\n");
  384.     return 0;
  385. }
  386. /* Control file transmission */
  387. doupload(argc,argv)
  388. int argc;
  389. char *argv[];
  390. {
  391.     struct tcb *tcb;
  392.     struct ax25_cb *axp;
  393. #ifdef NETROM
  394.     struct nr4cb *cb ;
  395. #endif
  396.  
  397.     if(current == NULLSESSION){
  398.         printf("No current session\n");
  399.         return 1;
  400.     }
  401.     if(argc > 1){
  402.         switch(current->type){
  403.         case TELNET:
  404.             tcb = current->cb.telnet->tcb;
  405.             break;
  406. #ifdef    AX25
  407.         case AX25TNC:
  408.             axp = current->cb.ax25_cb;
  409.             break;
  410. #endif
  411. #ifdef NETROM
  412.         case NRSESSION:
  413.             cb = current->cb.nr4_cb ;
  414.             break ;
  415. #endif
  416.         case FTP:
  417.             printf("Uploading on FTP control channel not supported\n");
  418.             return 1;
  419.         }
  420.         if(strcmp(argv[1],"stop") == 0 && current->upload != NULLFILE){
  421.             /* Abort upload */
  422.             fclose(current->upload);
  423.             current->upload = NULLFILE;
  424.             if(current->ufile != NULLCHAR){
  425.                 free(current->ufile);
  426.                 current->ufile = NULLCHAR;
  427.             }
  428.         }
  429.         /* Open upload file */
  430.         if((current->upload = fopen(argv[1],"r")) == NULLFILE){
  431.             printf("Can't read %s\n",argv[1]);
  432.             return 1;
  433.         }
  434.         current->ufile = malloc((unsigned)strlen(argv[1])+1);
  435.         strcpy(current->ufile,argv[1]);
  436.         /* All set, kick transmit upcall to get things rolling */
  437.         switch(current->type){
  438. #ifdef    AX25
  439.         case AX25TNC:
  440.             (*axp->t_upcall)(axp,axp->paclen * axp->maxframe);
  441.             break;
  442. #endif
  443. #ifdef NETROM
  444.         case NRSESSION:
  445.             (*cb->t_upcall)(cb, NR4MAXINFO) ;
  446.             break ;
  447. #endif
  448.         case TELNET:
  449.             (*tcb->t_upcall)(tcb,tcb->snd.wnd - tcb->sndcnt);
  450.             break;
  451.         }
  452.     }
  453.     if(current->ufile != NULLCHAR)
  454.         printf("Uploading %s\n",current->ufile);
  455.     else
  456.         printf("Uploading off\n");
  457.     return 0;
  458. }
  459.